12.5 Die Klassen »TextReader« und »TextWriter«  
Wie Sie in den vorhergehenden Abschnitten gesehen haben, stellt die Klasse Stream Operationen bereit, mit denen Sie unformatierte Daten byteweise lesen und schreiben können. Stream-Objekte bieten sich daher insbesondere für allgemeine Operationen an, beispielsweise für das Kopieren von Dateien. Die Klasse Stream beziehungsweise die daraus abgeleiteten Klassen sind aber weniger gut für textuelle Ein- und Ausgabeoperationen geeignet.
Um den üblichen Anforderungen von Textoperationen zu entsprechen, stellt die .NET-Klassenbibliothek die beiden abstrakten Klassen TextReader und TextWriter bereit. Objekte, die aus der Klasse Stream abgeleitet werden, unterstützen den vollständigen Satz an E/A-Operationen, also sowohl das Lesen als auch das Schreiben. Nun wird die Bearbeitung auf zwei Klassen aufgeteilt, die entweder nur lesen oder nur schreiben können.
Hier klicken, um das Bild zu Vergrößern
Abbildung 12.4 Objekthierarchie der »Reader«- und »Writer«-Klassen
TextReader und TextWriter sind abstrakt definiert und müssen daher abgeleitet werden. Das .NET Framework bietet solche Ableitungen mit StreamReader und -Writer sowie StringReader und -Writer an. Von TextWriter gibt es auch noch weitere, spezialisierte Ableitungen.
Im Folgenden werden wir uns mit den Klassen StreamReader/StreamWriter und StringReader/StringWriter beschäftigen. Der wesentliche Unterschied ist, dass StreamReader/StreamWriter mit Dateien und StringReader/StringWriter mit Zeichenketten operieren.
12.5.1 Die Klasse »StreamWriter« 
Die Konstruktoren der Klasse »StreamWriter«
Um das Verhalten einer Klasse und ihren Einsatzbereich zu verstehen, genügt ein Blick in die Liste der Methoden und Eigenschaften. Häufig geben aber auch die Konstruktoren einen entscheidenden Hinweis darauf, was wir von einer Klasse erwarten können.
Wir werden uns daher zunächst einigen Konstruktoren der Klasse StreamWriter zuwenden, um zu sehen, auf welcher Basis sich ein Objekt dieses Typs erzeugen lässt.
| Public Sub New (Stream)
|
| Public Sub New (String)
|
| Public Sub New (Stream, Encoding)
|
| Public Sub New (String, Boolean)
|
| Public Sub New (Stream, Encoding, Integer)
|
| Public Sub New (String, Boolean, Encoding)
|
| Public Sub New (String, Boolean, Encoding, Integer)
|
Es fällt zunächst auf, dass wir jedem Konstruktor entweder eine Zeichenfolge oder ein Objekt vom Typ Stream übergeben müssen. Entscheiden wir uns für eine Zeichenfolge, enthält diese die Pfadangabe zu einer Datei.
Da die Klasse Stream abstrakt ist, können wir natürlich keine Referenz auf ein konkretes Stream-Objekt übergeben. Aber die Klasse Stream wird abgeleitet, beispielsweise von FileStream. Die Referenz auf ein Objekt einer aus Stream abgeleiteten Klasse gilt aber nach den Paradigmen der Objektorientierung gleichzeitig als ein Objekt vom Typ der Basisklasse. Also kann dem Parameter im Konstruktor, der den Typ Stream erwartet, ein Objekt vom Typ einer aus Stream abgeleiteten Klasse übergeben werden.
Nun sehen wir uns natürlich sofort mit der Frage konfrontiert, welchen Sinn es hat, ein Stream-Objekt als Argument an den Konstruktor zu übergeben. Wie Sie sich vielleicht noch erinnern, werden die Stream-Objekte generell in zwei Typen klassifiziert: in Base-Streams und Pass-Through-Streams. Ein Base-Stream endet zum Beispiel direkt in einer Datei oder in einer Netzwerkverbindung, ein Pass-Through-Stream ist ein »Durchlaufobjekt«, das die Fähigkeiten eines Base-Streams erweitert.
Betrachten wir zunächst den Konstruktor der Klasse StreamWriter, der in einem String eine Pfadangabe entgegennimmt:
Ein Objekt, das basierend auf dieser Erstellungsroutine instanziiert wird, weiß, wohin die Daten geschrieben werden – nämlich in die Datei, die durch das String-Argument beschrieben wird, z. B.:
| Dim sw As StreamWriter = New StreamWriter("C:\MyText.txt")
|
Wir erzeugen mit dieser Anweisung einen Base-Stream, der die Daten – genauer gesagt eine Zeichenfolge – in eine Datei schreiben kann. Nun wollen wir ein anderes StreamWriter-Objekt erzeugen, diesmal allerdings auf Basis der Übergabe eines FileStream-Objekts.
| Dim fs As FileStream = New FileStream("C:\Test.txt", _
|
| FileMode.CreateNew)
|
| Dim sw As StreamWriter = New StreamWriter(fs)
|
In der ersten Anweisung wird ein Objekt vom Typ FileStream erstellt, das eine neue Datei namens Test.txt in der Root C:\ erzeugt. Dieses Objekt wird seinerseits als Argument an den Konstruktor der Klasse StreamWriter übergeben. Als Resultat liegt eine Hintereinanderschaltung von zwei Stream-Objekten vor, woraus sich Nutzen ziehen lässt. Wie Sie wissen, schreiben und lesen Objekte, die auf der Stream-Klasse basieren, nur elementare Bytes. Demgegenüber schreiben StreamWriter-Objekte Zeichen mit einer speziellen Verschlüsselung (Encoding) in den Datenstrom. Sie arbeiten im Endeffekt mit einem Datenstrom, der die Charakteristiken beider Datenflüsse kombiniert. In ähnlicher Weise könnten Sie natürlich auch einen MemoryStream oder NetworkStream als Argument übergeben.
Standardmäßig verschlüsselt StreamWriter nach UTF-8, eine Abweichung davon wird durch die Wahl eines Konstruktors erreicht, der einen Parameter vom Typ Encoding aus dem Namespace System.Text entgegennimmt. Sie können hier beispielsweise ein Objekt vom Typ UTF7Encoding oder UnicodeEncoding (entspricht der UTF-16 Kodierung) übergeben.
| Anmerkung
|
|
Schreiben wir Zeichen in einen Stream, müssen die Bytes in bestimmter Weise interpretierbar sein. Standardmäßig wird in Mitteleuropa zur Kodierung der ANSI-Zeichensatz (Codeseite 1252) benutzt, der Zeichencodes zwischen 0 und 255 zulässt und unter anderem auch Sonderzeichen wie »ä«, »ö« und »ü« beschreibt. Damit unterscheidet sich der ANSI-Zeichensatz vom ASCII-Zeichensatz, der nur die Codes von 0 bis 127 festlegt. Um einen Text korrekt zu übertragen und anzuzeigen, dürfte streng genommen nur der ASCII-Zeichensatz verwendet werden, weil nur die Codes 0 – 127 unter ANSI und ASCII identisch sind.
Um Probleme dieser Art zu vermeiden, wurde mit Unicode ein neuer Zeichensatz geschaffen. Allerdings hat auch Unicode unterschiedliche Formate, denn es wird zwischen UTF-7, UTF-8, UTF-16 und UTF-32 unterschieden. Der UTF-8-Zeichensatz ist wohl der wichtigste, denn er ist der Standard unter .NET. In diesem Zeichensatz werden Unicode-Zeichen in einer unterschiedlichen Anzahl Bytes verschlüsselt. Die ASCII-Zeichen werden in einem Byte gespeichert, alle anderen Zeichen in weiteren zwei bis vier Byte. Das hat den Vorteil, dass Systeme, die nur ASCII- oder ANSI-Zeichen verarbeiten, mit der UTF-8-Codierung klarkommen.
|
Einige Konstruktoren erwarten zusätzlich einen booleschen Wert. Dieser kommt nur im Zusammenhang mit den Konstruktoren vor, die in einer Zeichenfolge die Pfadangabe zu der Datei erhalten, in die der Datenstrom geschrieben werden soll. Mit True werden die zu schreibenden Daten an das Ende der Datei gehängt – vorausgesetzt, es existiert bereits eine Datei gleichen Namens in dem Verzeichnis. Mit der Übergabe von False wird eine existierende Datei überschrieben.
Der letzte Parameter, der Ihnen in zwei Konstruktoren zur Verfügung steht, empfängt einen Wert vom Typ Integer, mit dem Sie die Größe des Puffers beeinflussen können.
Das Schreiben in den Datenstrom
Schauen wir uns zunächst ein Codefragment an, mit dem wir eine Datei erzeugen und in dieser den obligatorischen Text »Visual Basic macht Spaß« schreiben:
| Dim sw As StreamWriter = New StreamWriter("C:\NewFile.txt")
|
| sw.WriteLine("Visual Basic ")
|
| sw.WriteLine("macht Spaß!")
|
| sw.Close()
|
Einfacher geht es nicht mehr! Zunächst wird ein Konstruktor aufgerufen und diesem zur Initialisierung des StreamWriter-Objekts eine Zeichenkette als Pfadangabe übergeben. Daraufhin wird entweder die Datei erzeugt oder eine existierende gleichnamige im angegebenen Verzeichnis überschrieben. Mit jedem Aufruf der von TextWriter geerbten Methode WriteLine wird eine Zeile in die Datei geschrieben und ihr am Ende ein Zeilenumbruch angehängt. Mit unserem Codefragment erzeugen wir also eine zweizeilige Textdatei.
Die Methode WriteLine ist vielfach überladen. Sie können ihr jeden bekannten Datentyp übergeben, sei es ein Integer oder ein Decimal, ein Char-Array oder eine Zeichenfolge.
| Public Overridable Sub WriteLine()
|
| Public Overridable Sub WriteLine(String)
|
| Public Overridable Sub WriteLine(Char())
|
| Public Overridable Sub WriteLine(Integer)
|
| ...
|
Es ist nicht nur der Name der Methode WriteLine, der einen Zusammenhang zwischen dieser Methode und der gleichnamigen der Klasse Console suggeriert. Diesen Zusammenhang gibt es tatsächlich, da die WriteLine-Methode von Console sich tatsächlich eines StreamWriter-Objekts bedient.
Nun liegt es nahe zu vermuten, dass StreamWriter eine zweite Methode zum Schreiben in den Datenstrom bereitstellt, die ohne den automatisch angehängten Zeilenumbruch in den Strom schreibt. Ein Blick in die Klassenbibliothek bestätigt die Vermutung: Es gibt eine Methode Write. Diese Methode ist genauso überladen wie die Methode WriteLine.
| Public Overridable Sub Write()
|
| Public Overridable Sub Write(String)
|
| Public Overridable Sub Write(Char())
|
| Public Overridable Sub Write(Integer)
|
| ...
|
Write und WriteLine bilden den Kern der Klasse StreamWriter. Viel mehr Methoden hat die Klasse auch nicht anzubieten, denn alle anderen sind bereits gute Bekannte: Close, um einen auf dieser Klasse basierenden Strom zu schließen, und Flush, um die sich im Puffer befindlichen Daten in den Strom zu schreiben und den Puffer zu leeren. Die folgende Tabelle gibt die wichtigsten Methoden eines StreamWriter-Objekts wieder.
Tabelle 12.17 Methoden eines »StreamWriter«-Objekts
| Methode
|
Beschreibung
|
| Close
|
Schließt das aktuelle Objekt sowie alle eingebetteten Streams.
|
| Flush
|
Schreibt die gepufferten Daten in den Stream und löscht danach den Inhalt des Puffers.
|
| Write
|
Schreibt in den Stream, ohne einen Zeilenumbruch anzuhängen.
|
| WriteLine
|
Schreibt in den Stream und schließt mit einem Zeilenumbruch ab.
|
Die Eigenschaften der Klasse »StreamWriter«
Mit AutoFlush veranlassen Sie das Schreiben der Daten aus dem Puffer in den Datenstrom, sobald eine der Write-/WriteLine-Methoden aufgerufen wird und diese Eigenschaft True gesetzt ist. Wollen Sie das aktuelle Textformat erfahren, können Sie die Eigenschaft Encoding auswerten:
| Dim sw As StreamWriter = _
|
| New StreamWriter("C:\NewFile.txt", False, Encoding.Unicode)
|
| Console.WriteLine("Format: {0}", sw.Encoding.ToString())
|
Als dritte und letzte Eigenschaft steht Ihnen noch BaseStream zur Verfügung, die das Objekt des Base-Streams liefert, auf dem das StreamWriter-Objekt basiert.
Tabelle 12.18 Die Eigenschaften der Klasse »StreamWriter«
| Eigenschaften
|
Beschreibung
|
| AutoFlush
|
Löscht den Puffer nach jedem Aufruf von Write oder WriteLine.
|
| BaseStream
|
Liefert eine Referenz auf den Base-Stream zurück.
|
| Encoding
|
Liefert das aktuelle Encoding-Schema zurück.
|
12.5.2 Die Klasse »StreamReader«
Die aus der Klasse TextReader abgeleitete Klasse StreamReader ist das Gegenstück zu der im vorigen Abschnitt besprochenen Klasse StreamWriter. Betrachtet man ihre Möglichkeiten, sind die Klassen praktisch identisch – abgesehen von der Tatsache, dass das charakteristische Merkmal dieser Klasse in der Fähigkeit zu finden ist, Daten einer bestimmten Codierung aus einem Strom zu lesen.
Die Konstruktoren ähneln denen der Klasse StreamWriter. Sie nehmen im einfachsten Fall die Referenz auf einen Stream oder eine Pfadangabe als String entgegen. Sie gestatten aber auch, die eingelesenen Zeichen nach einem durch Encoding beschriebenen Schema zu interpretieren oder die Puffergröße zu variieren.
Die folgende Tabelle enthält die wichtigsten Methoden eines StreamReaders.
Tabelle 12.19 Methoden der Klasse »StreamReader«
| Methode
|
Beschreibung
|
| Peek
|
Liest ein Zeichen aus dem Strom und liefert den das Zeichen repräsentierenden Integer-Wert zurück, ohne es zu verarbeiten. Der Zeiger wird nicht auf die Position des folgenden Zeichens gesetzt, wenn Peek aufgerufen wird, sondern verbleibt in seiner Stellung. Verweist der Zeiger hinter den Datenstrom, ist der Rückgabewert –1.
|
| Read
|
Liest ein oder mehrere Zeichen aus dem Strom und liefert den das Zeichen repräsentierenden int-Wert zurück. Ist kein Zeichen mehr verfügbar, ist der Rückgabewert –1. Der Positionszeiger verweist auf das nächste zu lesende Zeichen. Eine zweite Variante dieser überladenen Methode liefert die Anzahl der eingelesenen Zeichen.
|
| ReadLine
|
Liest eine Zeile aus dem Datenstrom – entweder bis zum Zeilenumbruch oder bis zum Ende des Stroms. Der Rückgabewert ist vom Typ String.
|
| ReadToEnd
|
Liest von der aktuellen Position des Positionszeigers bis zum Ende des Stroms alle Zeichen ein.
|
Wir wollen nun an einem Codebeispiel das Lesen aus einem Strom testen.
| ' ----------------------------------------------------------
|
| ' Beispiel: ...\Kapitel 12\StreamReaderDemo
|
| ' ----------------------------------------------------------
|
| Imports System.IO
|
| Module Module1
|
| Sub Main()
|
| ' Datei erzeugen und mit Text füllen
|
| Dim sw As StreamWriter = _
|
| New StreamWriter("C:\MyTest.kkl")
|
| sw.WriteLine("Visual Basic ")
|
| sw.WriteLine("macht viel Spass.")
|
| sw.Write("Richtig??")
|
| sw.Close()
|
| ' die Datei an der Konsole einlesen
|
| Dim sr As StreamReader = _
|
| New StreamReader("C:\MyTest.kkl")
|
| Do While (sr.Peek() <> –1)
|
| Console.WriteLine(sr.ReadLine())
|
| Loop
|
| sr.Close()
|
| Console.ReadLine()
|
| End Sub
|
| End Module
|
Zunächst wird mit einem StreamWriter-Objekt eine Datei mit dem Namen MyTest.kkl erzeugt. Die Dateierweiterung ist frei gewählt, sie muss nicht zwangsläufig .txt zur Kennzeichnung als Textdatei lauten. Wichtig ist nur, die Daten der Datei beim späteren Lesevorgang richtig zu interpretieren. Solange wir wissen, dass wir es mit einer Textdatei zu tun haben, bereitet uns eine individuelle Dateierweiterung keine Probleme.
In den Datenstrom sw vom Typ StreamWriter werden drei Textzeilen geschrieben. Danach darf man nicht vergessen, den Strom wieder zu schließen, denn ansonsten wird man mit einer Fehlermeldung konfrontiert, wenn nachfolgend der Versuch unternommen wird, die Datei zum Lesen zu öffnen.
Zum Lesen des Dateiinhalts bedienen wir uns eines Objekts vom Typ StreamReader, dessen Konstruktor wir den Pfad zu der Datei übergeben. Mit der ReadLine-Methode wird Zeile für Zeile aus dem Strom gelesen. Um den Lesevorgang zum richtigen Zeitpunkt wieder zu beenden, müssen wir das Ende der Datei feststellen. Hierbei ist die Methode Peek behilflich, deren Rückgabewert –1 ist, wenn der Zeiger auf die Position hinter dem Ende des Stroms verweist. Dieses Verhalten machen wir uns zunutze, indem wir daraus die Abbruchbedingung der Schleife formulieren. In der Do-While-Schleife werden so lange mit der ReadLine-Methode des StreamReader-Objekts Zeilen aus dem Datenstrom geholt (und dabei automatisch der Zeiger auf das nächste einzulesende Zeichen gesetzt), bis die Abbruchbedingung erfüllt wird, d. h., Peek –1 zurückliefert.
Die Ausgabe an der Konsole wird lauten:
| Visual Basic
|
| macht viel Spass.
|
| Richtig??
|
Da wir die komplette Textdatei auslesen wollen, könnten wir auch einen einfacheren Weg gehen und die komplette Schleife gegen die folgende Programmcodezeile austauschen:
| Console.WriteLine(sr.ReadToEnd())
|
Die »Read«-Methode der Klasse »StreamReader«
Die Read-Methode der Klasse StreamReader ist unter bestimmten Umständen flexibler einsetzbar als ReadLine und wie folgt definiert:
| Public Overrides Function Read() As Integer
|
| Public Overrides Function Read(buffer As Char(), _
|
| index As Integer, count As Integer) As Integer
|
Die parameterlose Variante liest ein Zeichen ein und setzt danach den Positionszeiger auf das nächste zu lesende Zeichen.
Im ersten Parameter der parametrisierten Methode wird die Referenz auf ein char-Array übergeben. In das Array wird das Ergebnis der Leseoperation geschrieben, beginnend ab dem Array-Index, der dem zweiten Parameter übergeben wird. Im dritten Parameter teilen Sie der Methode die Anzahl der aus dem Stream einzulesenden Zeichen mit. Diesen Wert können Sie ermitteln, indem Sie ein Objekt vom Typ FileInfo mit Angabe der Datei, die eingelesen werden soll, erzeugen. Die Methode Length dieses Objekts liefert die Länge der Datei.
| Sub Main()
|
| ' Datei erzeugen und mit Text füllen
|
| Dim sw As StreamWriter = New StreamWriter("C:\MyTest.kkl")
|
| sw.WriteLine("Visual Basic 2005")
|
| sw.WriteLine("ist eine moderne Sprache")
|
| sw.Write("der .NET-Plattform.")
|
| sw.Close()
|
| ' die Datei wieder an der Konsole einlesen
|
| Dim sr As StreamReader = New StreamReader("C:\MyTest.kkl")
|
| Dim fi As FileInfo = New FileInfo("C:\MyTest.kkl")
|
| Dim bArr(fi.Length – 1) As Char
|
| sr.Read(bArr, 0, fi.Length)
|
| Dim i As Integer
|
| For i = 0 To bArr.Length – 1
|
| Console.Write(bArr(i))
|
| Next
|
| sr.Close()
|
| Console.ReadLine()
|
| End Sub
|
Die von der Methode Length zurückgelieferte Zahl beträgt in unserem Beispiel 56. Wenn Sie die Zeichen zählen, werden Sie zunächst feststellen, dass offensichtlich nur 52 Zeichen an die Datei übergeben worden sind. Die Differenz von vier Zeichen wird durch die beiden Methodenaufrufe WriteLine des Objekts StreamWriter verursacht, die jeweils einen Zeilenumbruch bestehend aus den ASCII-Zeichen 10 und 13 anhängen. Mit
| sr.Read(bArr, 0, fi.Length)
|
lesen wir alle Zeichen der Datei, die durch die Referenz sr beschrieben wird, in das Char-Array bArr ein, wobei das erste Zeichen dem 0-indizierten Element zugewiesen wird.
12.5.3 Die Klassen »StringWriter« und »StringReader«
Während die Klassen StreamReader/StreamWriter auf einem Pfad oder einem anderen Datenstrom basieren, führen die Klassen StringReader/StringWriter – wie schon durch die Namensgebung zum Ausdruck gebracht wird – den Datenstrom auf Zeichenfolgen zurück.
StringReader liest die einzelnen Zeichen eines Strings und hat deshalb auch nur einen Konstruktor, der in seinem Parameter einen String entgegennimmt:
Die Klasse beschränkt sich auf die Anwendungsfälle, in denen eine Zeichenfolge als Stream angesehen werden soll. Daher enthält diese Klasse auch keine Eigenschaften, sondern nur einige ReadXxx-Methoden. Diese Methoden leisten dasselbe wie die gleichnamigen Methoden der Klasse StreamReader. Ergänzt wird die Methodenliste noch durch Peek, um ein Zeichen zu lesen, ohne dabei den Zeiger auf das nächste zu lesende Zeichen zu setzen.
| Public Overrides Function Read() As Integer
|
| Public Overrides Function Read(buffer As Char(), _
|
| index As Integer, count As Integer) As Integer
|
| Public Overrides Function ReadLine() As String
|
| Public Overrides Function ReadToEnd() As String
|
| Public Overrides Function Peek() As Integer
|
Dazu ein Beispiel:
| Dim str As String = "Erste Zeile der Zeichenfolge" & vbCrLf
|
| str &= "Zweite Zeile der Zeichenfolge" & vbCrLf
|
| str &= "Dritte Zeile der Zeichenfolge"
|
| Dim sr As StringReader = New StringReader(str)
|
| ' Einlesen der ersten und zweiten Zeile
|
| Console.WriteLine(sr.ReadLine())
|
| Console.WriteLine(sr.ReadLine())
|
StringWriter schreibt die Ausgabe in ein Objekt vom Typ StringBuilder. Das kommt bereits in den Konstruktoren zum Ausdruck, die entweder parameterlos oder den Typ StringBuilder bzw. IFormatProvider erwarten.
| Public Sub New()
|
| Public Sub New(IFormatProvider)
|
| Public Sub New(StringBuilder)
|
| Public Sub New(StringBuilder, IFormatProvider)
|
Zum Schreiben in das StringWriter-Objekt wird die Methode Write benutzt, der man jeden Datentyp als Parameter übergeben kann. Ansonsten wartet die Klasse nur noch mit einer erwähnenswerten Methode auf: GetStringBuilder, um das Objekt, das von diesem Stream beschrieben wird, zurückzuliefern.
| Dim sw As StringWriter = New StringWriter()
|
| sw.Write("Text des StringWriter-Objekts")
|
| Console.WriteLine(sw.GetStringBuilder())
|
|
